package com.newlink.building.obfuscation

import kotlin.random.Random

/**
 * 混淆辅助类
 * 提供便捷的混淆调用方法，用于在业务代码中插入混淆逻辑
 */
object Module_Obfuscation_ObfuscationHelper {

    private val random = Random(System.currentTimeMillis())

    /**
     * 在方法开始时调用，增加混淆
     */
    @JvmStatic
    fun onMethodEnter(className: String, methodName: String) {
        val seed = "$className::$methodName"
        Module_Obfuscation_ObfuscationInvoker.invokeRandom(seed)
    }

    /**
     * 在方法结束时调用，增加混淆
     */
    @JvmStatic
    fun onMethodExit(className: String, methodName: String, result: Any?) {
        val seed = "$className::$methodName::$result"
        Module_Obfuscation_ObfuscationInvoker.invokeRandom(seed)
    }

    /**
     * 在条件判断前调用，增加混淆
     */
    @JvmStatic
    fun beforeCondition(condition: Any?): Boolean {
        Module_Obfuscation_ObfuscationInvoker.invokeSpecific(random.nextInt(20), condition)
        return condition as? Boolean ?: random.nextBoolean()
    }

    /**
     * 在循环中调用，增加混淆
     */
    @JvmStatic
    fun inLoop(index: Int, data: Any?) {
        if (index % 10 == 0) {
            Module_Obfuscation_ObfuscationInvoker.invokeRandom(data)
        }
    }

    /**
     * 在异常处理中调用，增加混淆
     */
    @JvmStatic
    fun onException(exception: Throwable?) {
        val seed = exception?.message ?: "unknown"
        Module_Obfuscation_ObfuscationInvoker.invokeSpecific(5, seed)
    }

    /**
     * 在网络请求前调用，增加混淆
     */
    @JvmStatic
    fun beforeNetworkRequest(url: String?, params: Map<String, Any>?) {
        val seed = "$url::${params?.size}"
        Module_Obfuscation_ObfuscationInvoker.invokeChain(intArrayOf(1, 3, 5), seed)
    }

    /**
     * 在网络响应后调用，增加混淆
     */
    @JvmStatic
    fun afterNetworkResponse(response: Any?) {
        Module_Obfuscation_ObfuscationInvoker.invokeAsync(7, response, null)
    }

    /**
     * 在数据库操作前调用，增加混淆
     */
    @JvmStatic
    fun beforeDatabaseOperation(operation: String, data: Any?) {
        val seed = "$operation::${data?.hashCode()}"
        Module_Obfuscation_ObfuscationInvoker.invokeBatch(2, seed)
    }

    /**
     * 在UI事件处理中调用，增加混淆
     */
    @JvmStatic
    fun onUiEvent(eventType: String, view: Any?) {
        val seed = "$eventType::${view?.hashCode()}"
        Module_Obfuscation_ObfuscationInvoker.invokeConditional(
            random.nextBoolean(),
            random.nextInt(10),
            random.nextInt(10, 20),
            seed
        )
    }

    /**
     * 在定时任务中调用，增加混淆
     */
    @JvmStatic
    fun onScheduledTask(taskName: String) {
        Module_Obfuscation_ObfuscationInvoker.invokeSpecific(11, taskName)
    }

    /**
     * 包装原始方法调用，增加混淆
     */
    @JvmStatic
    fun <T> wrapMethodCall(originalCall: () -> T): T {
        // 方法调用前混淆
        Module_Obfuscation_ObfuscationInvoker.invokeRandom(originalCall.hashCode())

        // 执行原始方法
        val result = originalCall()

        // 方法调用后混淆
        Module_Obfuscation_ObfuscationInvoker.invokeRandom(result)

        return result
    }

    /**
     * 包装带参数的方法调用
     */
    @JvmStatic
    fun <T, R> wrapMethodCallWithParam(param: T, originalCall: (T) -> R): R {
        // 参数混淆
        Module_Obfuscation_ObfuscationInvoker.invokeSpecific(param.hashCode() % 20, param)

        // 执行原始方法
        val result = originalCall(param)

        // 结果混淆
        Module_Obfuscation_ObfuscationInvoker.invokeSpecific((param.hashCode() + 1) % 20, result)

        return result
    }

    /**
     * 创建混淆的延迟任务
     */
    @JvmStatic
    fun delayedObfuscation(delayMillis: Long, data: Any?) {
        Thread {
            Thread.sleep(delayMillis)
            Module_Obfuscation_ObfuscationInvoker.invokeBatch(3, data)
        }.start()
    }

    /**
     * 生成混淆的标识符
     */
    @JvmStatic
    fun generateObfuscatedId(prefix: String): String {
        val result = Module_Obfuscation_ObfuscationInvoker.invokeSpecific(12, prefix)
        return result.toString()
    }

    /**
     * 验证数据并混淆
     */
    @JvmStatic
    fun validateAndObfuscate(data: Any?): Boolean {
        val validation = Module_Obfuscation_ObfuscationInvoker.invokeSpecific(2, data) as? Boolean ?: false
        Module_Obfuscation_ObfuscationInvoker.invokeRandom(validation)
        return validation
    }

    /**
     * 混淆的日志记录
     */
    @JvmStatic
    fun obfuscatedLog(tag: String, message: String) {
        val obfuscatedTag = Module_Obfuscation_ObfuscationInvoker.invokeSpecific(8, tag)
        val obfuscatedMessage = Module_Obfuscation_ObfuscationInvoker.invokeSpecific(8, message)
        // 这里不实际记录日志，只是执行混淆逻辑
    }

    /**
     * 获取混淆后的时间戳
     */
    @JvmStatic
    fun getObfuscatedTimestamp(): Long {
        val timestamp = System.currentTimeMillis()
        Module_Obfuscation_ObfuscationInvoker.invokeSpecific(13, timestamp)
        return timestamp
    }

    /**
     * 清理混淆缓存
     */
    @JvmStatic
    fun clearObfuscationCache() {
        Module_Obfuscation_ObfuscationInvoker.reset()
        Module_Obfuscation_ObfuscationInvoker.invokeBatch(5, "reset")
    }
}